/**
 * JSON 格式生成器
 * 适用于 Web、React Native 等平台
 */
class JsonGenerator {
  static async generate(data, platform = "web") {
    if (!data || typeof data !== "object") {
      throw new Error("数据必须是一个对象");
    }

    // 检查是否有嵌套键
    const hasNestedKeys = Object.keys(data).some((key) => key.includes("."));

    // 根据平台和键结构优化JSON格式
    let result;

    switch (platform) {
      case "web":
      case "rn":
      default:
        if (hasNestedKeys) {
          // 如果有嵌套键，使用嵌套JSON格式
          result = this.generateNestedJson(data);
        } else {
          // 标准扁平JSON格式
          result = this.generateStandardJson(data);
        }
        break;
    }

    return result;
  }

  static generateStandardJson(data) {
    // 对键进行排序以保持一致性
    const sortedData = {};
    Object.keys(data)
      .sort()
      .forEach((key) => {
        sortedData[key] = data[key];
      });

    return JSON.stringify(sortedData, null, 2);
  }

  static generateFlatJson(data) {
    // 扁平化JSON，适用于某些国际化库
    const flatData = {};

    Object.keys(data).forEach((key) => {
      // 如果值包含换行符，保持原样
      flatData[key] = data[key];
    });

    return JSON.stringify(flatData, null, 2);
  }

  static validateKeysForNesting(data) {
    // 检查键的嵌套冲突
    const sortedKeys = Object.keys(data).sort();
    const conflicts = [];

    for (let i = 0; i < sortedKeys.length; i++) {
      const currentKey = sortedKeys[i];

      for (let j = i + 1; j < sortedKeys.length; j++) {
        const compareKey = sortedKeys[j];

        // 检查是否一个键是另一个键的前缀
        if (compareKey.startsWith(currentKey + ".")) {
          conflicts.push({
            baseKey: currentKey,
            nestedKey: compareKey,
            conflict: `键 "${currentKey}" 与 "${compareKey}" 存在嵌套冲突`,
          });
        }
      }
    }

    return conflicts;
  }

  static generateNestedJson(data) {
    // 首先检查键冲突
    const conflicts = this.validateKeysForNesting(data);

    if (conflicts.length > 0) {
      console.error("\n❌ 检测到键嵌套冲突，无法生成嵌套结构：\n");
      conflicts.forEach((conflict) => {
        console.error(`   🔸 ${conflict.conflict}`);
      });
      console.error("\n💡 解决方案：");
      console.error("   1. 重命名冲突的键，避免父子关系");
      console.error("   2. 或者在表格中删除冲突的键\n");

      throw new Error(
        `键嵌套冲突：检测到 ${conflicts.length} 个冲突。请修复表格中的键名冲突后重试。`
      );
    }

    // 嵌套JSON格式，根据键的点分隔符创建嵌套结构
    const nestedData = {};

    // 对键进行排序，确保处理顺序一致
    const sortedKeys = Object.keys(data).sort();

    sortedKeys.forEach((key) => {
      const keys = key.split(".");
      let current = nestedData;

      for (let i = 0; i < keys.length - 1; i++) {
        const currentKey = keys[i];

        if (!current[currentKey]) {
          current[currentKey] = {};
        }
        current = current[currentKey];
      }

      const finalKey = keys[keys.length - 1];
      current[finalKey] = data[key];
    });

    return JSON.stringify(nestedData, null, 2);
  }
}

module.exports = JsonGenerator;
